home *** CD-ROM | disk | FTP | other *** search
/ MacTech 1 to 12 / MacTech-vol-1-12.toast / Source / MacTech® Magazine / Volume 03 - 1987 / 03.01 Jan 87 / c source / mem.c < prev    next >
Encoding:
C/C++ Source or Header  |  1986-12-05  |  7.0 KB  |  391 lines  |  [TEXT/KAHL]
  1. /* mem.c
  2.  *
  3.  *        explore memory allocation
  4.  *
  5.  */
  6.  
  7.  #include    "abc.h"
  8.  #include    "MemoryMgr.h"
  9.  #include    "Quickdraw.h"
  10.  #include    "EventMgr.h"
  11.  #include    "WindowMgr.h"
  12.  #include    "MenuMgr.h"
  13.  #include    "FontMgr.h"
  14.  
  15.  /* defines for menu ID's */
  16.  
  17.  #define        Mdesk        100
  18.  #define        Mfile        101
  19.  #define        Medit        102
  20.  #define        Mmem        103
  21.  
  22.  /* Window items */
  23.  /* File */
  24.  #define        iNew        1
  25.  #define        iClose    2
  26.  #define        iQuit        3
  27.  
  28.  /* Edit */
  29.  #define        iUndo        1
  30.  #define        iCut        3
  31.  #define        iCopy        4
  32.  #define        iPaste    5
  33.  
  34.  /* Memory */
  35.  #define        iZone        1
  36.  #define        iMzone    2
  37.  #define        iInfo        3
  38.  #define        iHand        4
  39.  #define        iPtr        5
  40.  #define        iFreeH    6
  41.  #define        iFreeP    7
  42.  
  43.  /* Global variables */
  44.  
  45.  MenuHandle        menuDesk;    /* menu handles */
  46.  MenuHandle        menuFile;
  47.  MenuHandle        menuEdit;
  48.  MenuHandle        menuMem;
  49.  
  50.  WindowPtr        theWindow;
  51.  WindowRecord    windowRec;
  52.  Rect                dragbound;
  53.  Rect                limitRect;
  54.  
  55. /*
  56.  * structure needed to examine heap not typically
  57.  * supplied by Mac development systems because normal
  58.  * applications do not need to examine the heap. 
  59.  */
  60.  struct memheads
  61.  {
  62.      long            physsize;
  63.      long            relhand;
  64.  };
  65.   
  66. main()
  67. {
  68.     initsys();    /* sys init */
  69.     initapp();    /* appl init */
  70.     eventloop();
  71. }
  72.  
  73. /* system initialization 
  74.  */
  75. initsys()        
  76. {                    
  77.     InitGraf(&thePort);    
  78.     InitFonts();            
  79.     InitWindows();
  80.     InitCursor();
  81.     InitMenus();
  82.     theWindow = Nil;        /* no window */
  83.     SetRect(&dragbound,0,0,512,250);
  84.     SetRect(&limitRect,60,40,508,244);
  85. }
  86.  
  87. /*
  88.  *    application initialization
  89.  *        Sets up menus.
  90.  */
  91. initapp()
  92. {
  93.     setupmenu();
  94. }
  95.  
  96. /*
  97.  * set up application's menus
  98.  *        Each menu is a separate group
  99.  *        of lines.  
  100.  */
  101. setupmenu()
  102. {
  103.     menuDesk = NewMenu(Mdesk,CtoPstr("\24"));
  104.     AddResMenu (menuDesk, 'DRVR');
  105.     InsertMenu (menuDesk, 0);
  106.     
  107.     menuFile = NewMenu(Mfile, CtoPstr("File"));
  108.     AppendMenu (menuFile, 
  109.         CtoPstr("New/N;Close;Quit/Q"));
  110.     InsertMenu (menuFile, 0);
  111.     
  112.     menuEdit = NewMenu(Medit, CtoPstr("Edit"));
  113.     AppendMenu (menuEdit, 
  114.         CtoPstr("(Undo/Z;(-;(Cut/X;(Copy/C;(Paste/V;(Clear"));
  115.     InsertMenu (menuEdit, 0);
  116.     
  117.     menuMem = NewMenu(Mmem, CtoPstr("Memory"));
  118.     AppendMenu (menuMem,
  119.         CtoPstr("Show Zone;Max Zone;Zone Info;New Handle;New Pointer"));
  120.     AppendMenu (menuMem,CtoPstr("Free Handle;Free Pointer"));
  121.     InsertMenu (menuMem, 0);
  122.     
  123.     DrawMenuBar();
  124. }
  125.         
  126. /*    Event Loop 
  127.  *        Loop forever until Quit
  128.  */
  129. eventloop()
  130. {
  131.     EventRecord        theEvent;
  132.     char                c;
  133.     short                windowcode;
  134.     WindowPtr        ww;
  135.     
  136.     while(True)
  137.         {
  138.         if (theWindow)                    /* this code is here to */
  139.             {                                /* prevent closing an */
  140.             EnableItem(menuFile,2);    /* already closed window */
  141.             DisableItem(menuFile,1);
  142.             }
  143.         else                                
  144.             {                                
  145.             EnableItem(menuFile,1);
  146.             DisableItem(menuFile,2);
  147.             }
  148.         if (GetNextEvent(everyEvent,&theEvent))
  149.           
  150.             switch(theEvent.what)                    
  151.                 {                        /* only check key and */
  152.                 case mouseDown:
  153.                     domousedown(&theEvent);
  154.                     break;
  155.                 default:
  156.                     break;
  157.                 }
  158.             
  159.         }
  160. }
  161.  
  162. /* domousedown
  163.  *        handle mouse down events
  164.  */
  165. domousedown(er)
  166.     EventRecord    *er;
  167. {
  168.     short            windowcode;
  169.     WindowPtr    whichWindow;
  170.     short            ingo;
  171.     long            size;
  172.     long            newsize;
  173.     RgnPtr        rp;
  174.     Rect            box;
  175.     Rect            *boxp;
  176.     
  177.     windowcode = FindWindow(er->where, 
  178.                                     &whichWindow);
  179.     switch (windowcode)
  180.         {
  181.         case inDesk:
  182.             if (theWindow notequal 0)
  183.                 {
  184.                 HiliteWindow(theWindow, False);
  185.                 DrawGrowIcon(theWindow);
  186.                 }
  187.             break;
  188.         case inMenuBar:
  189.             domenu(MenuSelect(er->where));
  190.             break;
  191.         }
  192. }
  193.     
  194. /* domenu
  195.  *        handles menu activity
  196.  *        simply a dispatcher for each
  197.  *        menu.
  198.  */
  199. domenu(mc)
  200.     long            mc;    /* menu result */
  201. {
  202.     short            menuId;
  203.     short            menuitem;
  204.     
  205.     menuId = HiWord(mc);
  206.     menuitem = LoWord(mc);
  207.     
  208.     switch (menuId)
  209.         {
  210.         case Mdesk : break;
  211.                         /* not handling DA's */
  212.         case Mfile : dofile(menuitem);
  213.                          break;
  214.         case Mmem  : domem(menuitem);
  215.                         break;
  216.         }
  217.     HiliteMenu(0);
  218. }
  219.  
  220. domem(item)
  221.     short        item;
  222. {
  223.     THz                    zone;
  224.     static long            size = 1024;
  225.     static Handle        hand = 0;
  226.     static Ptr            ptr = 0;
  227.     struct memheads    *memhead;
  228.     
  229.     switch (item)
  230.         {
  231.         case iZone :
  232.             zone = GetZone();
  233.             printw("\nzone %ld ",zone);
  234.             showzone(zone);
  235.             break;
  236.         case iMzone :
  237.             MaxApplZone();
  238.             break;
  239.         case iInfo :
  240.             zone = GetZone();
  241.             countzone(zone);
  242.             break;
  243.         case iHand :
  244.             hand = NewHandle(size);
  245.             printw("\nhandle %ld pointer %lx error %d ",hand,*hand,MemError());
  246.             printw(" free mem %ld ",FreeMem());
  247.             size = size * 2;
  248.             break;
  249.         case iPtr :
  250.             ptr = NewPtr(size);
  251.             printw("\npointer %ld error %d free mem %ld",ptr,MemError(),FreeMem());
  252.             showhead(ptr-8);
  253.             break;
  254.         case iFreeH :
  255.             if (hand equals 0)
  256.                 printw("\nNo current handle to free");
  257.             else
  258.                 {
  259.                 DisposHandle(hand);
  260.                 hand = 0;
  261.                 }
  262.             break;
  263.         case iFreeP :
  264.             if (ptr equals 0)
  265.                 printw("\nNo current pointer to free");
  266.             else
  267.                 {
  268.                 DisposPtr(ptr);
  269.                 ptr = 0;
  270.                 }
  271.         }
  272.     
  273. }
  274.  
  275. showhead(head)
  276.     struct memheads    *head;
  277. {
  278.     uchar                    tagbyte;
  279.     
  280.     printw ("\naddress %ld ",(char*)head + 8);
  281.     tagbyte = head->physsize >> 24;
  282.     printw ("size correction %d ",tagbyte & 0xF);
  283.     tagbyte >>= 6;
  284.     switch (tagbyte)
  285.         {
  286.         case 0:
  287.             printw(" free block ");
  288.             break;
  289.         case 1:
  290.             printw(" non rel    ");
  291.             break;
  292.         case 2:
  293.             printw(" rel        ");
  294.             break;
  295.         }
  296.     printw(" physical size %ld ",head->physsize & 0x00FFFFFF);
  297.     return (tagbyte);
  298. }
  299.  
  300. showzone(zone)
  301.     THz        zone;
  302. {
  303.     struct memheads    *memhead;
  304.     short                    tblocks = 0;
  305.     short                    tfree = 0;
  306.     short                    trel = 0;
  307.     short                    tnonrel = 0;
  308.     
  309.     memhead = (struct memheads*)&zone->heapData;
  310.     while (memhead < (struct memheads*)zone->bkLim)
  311.         {
  312.         switch (showhead(memhead))
  313.             {
  314.             case 0 : tfree++; break;
  315.             case 1 : tnonrel++; break;
  316.             case 2 :    trel++; break;
  317.             }
  318.         tblocks++;
  319.         memhead = (struct memheads*)((char*)memhead + (memhead->physsize & 0x00FFFFFF));
  320.         }
  321.     printw("\n blocks %d free %d relocatable %d non-relocatable %d ",
  322.                   tblocks, tfree, trel,tnonrel);
  323. }
  324.             
  325. countzone(zone)
  326.     THz        zone;
  327. {
  328.     struct memheads    *memhead;
  329.     short                    tblocks = 0;
  330.     short                    tfree = 0;
  331.     short                    trel = 0;
  332.     short                    tnonrel = 0;
  333.     uchar                    tagbyte;
  334.     
  335.     memhead = (struct memheads*)&zone->heapData;
  336.     while (memhead < (struct memheads*)zone->bkLim)
  337.         {
  338.         tagbyte = memhead->physsize >> 24;
  339.         tagbyte >>= 6;
  340.         switch (tagbyte)
  341.             {
  342.             case 0 : tfree++; break;
  343.             case 1 : tnonrel++; break;
  344.             case 2 :    trel++; break;
  345.             }
  346.         tblocks++;
  347.         memhead = (struct memheads*)((char*)memhead + (memhead->physsize & 0x00FFFFFF));
  348.         }
  349.     printw("\n blocks %d free %d relocatable %d non-relocatable %d ",
  350.                   tblocks, tfree, trel, tnonrel);
  351. }
  352.             
  353. /* dofile
  354.  *        handles file menu
  355.  */
  356. dofile(item)
  357.     short        item;
  358. {
  359.     char        *title1;            /* first title for window */
  360.     Rect        boundsRect;
  361.     
  362.     switch (item)
  363.         {
  364.         case iNew :        /* open the window */
  365.             title1 = "ABC Window";
  366.             SetRect(&boundsRect,50,50,400,200);
  367.             theWindow = NewWindow(&windowRec, &boundsRect,
  368.                             CtoPstr(title1),True,documentProc,
  369.                             (WindowPtr) -1, True, 0);
  370.             DrawGrowIcon(theWindow);
  371.             PtoCstr(title1);
  372.             DisableItem(menuFile,1);
  373.             EnableItem(menuFile,2);
  374.             break;
  375.         
  376.         case iClose :        /* close the window */
  377.             CloseWindow(theWindow);
  378.             theWindow = Nil;
  379.             DisableItem(menuFile,2);
  380.             EnableItem(menuFile,1);
  381.             break;
  382.         
  383.         case iQuit :        /* Quit */
  384.             ExitToShell();
  385.             break;    
  386.         }
  387. }
  388.  
  389.  
  390.  
  391.